/**
 * 该文件可自行根据业务逻辑进行调整
 */
import type { HttpResponse } from '@vben/request';

import { useAppConfig } from '@vben/hooks';
import { preferences } from '@vben/preferences';
import {
  authenticateResponseInterceptor,
  errorMessageResponseInterceptor,
  RequestClient,
} from '@vben/request';
import { useAccessStore } from '@vben/stores';

import { message } from 'ant-design-vue';

import { useAuthStore } from '#/store';
import { tokenManager } from '#/utils/token-manager';

import { refreshTokenApi } from './core';

const { apiURL } = useAppConfig(import.meta.env, import.meta.env.PROD);

function createRequestClient(baseURL: string) {
  const client = new RequestClient({
    baseURL,
  });

  /**
   * 重新认证逻辑 - Token过期直接跳转登录页
   */
  async function doReAuthenticate() {
    console.warn('Token已过期，跳转到登录页');
    const accessStore = useAccessStore();
    const authStore = useAuthStore();

    // 停止自动续期任务
    tokenManager.stopAutoRefreshTask();

    // 清除所有认证相关状态
    accessStore.setAccessToken(null);
    accessStore.setRefreshToken(null);
    accessStore.setLoginExpired(false);
    accessStore.setIsAccessChecked(false);

    // 直接跳转到登录页
    await authStore.logout();
  }

  /**
   * 刷新token逻辑
   */
  async function doRefreshToken() {
    // 🔥 检查是否允许自动续期，如果不允许则直接触发重新认证
    if (!tokenManager.isAutoRefreshEnabled()) {
      console.warn('自动续期已关闭，Token过期后需要重新登录');
      await doReAuthenticate();
      throw new Error('自动续期已关闭，请重新登录');
    }

    try {
      const accessStore = useAccessStore();
      const resp = await refreshTokenApi();
      const newToken = resp.data;
      accessStore.setAccessToken(newToken);
      console.log('Token刷新成功，新Token已设置');
      return newToken;
    } catch (error) {
      console.error('Token刷新失败，触发重新认证流程:', error);

      // 刷新失败时，清除所有认证状态
      const accessStore = useAccessStore();
      accessStore.setAccessToken(null);
      accessStore.setRefreshToken(null);
      accessStore.setLoginExpired(false);
      accessStore.setIsAccessChecked(false);

      // 停止自动续期任务
      tokenManager.stopAutoRefreshTask();

      // 抛出错误，让authenticateResponseInterceptor处理
      throw error;
    }
  }

  function formatToken(token: null | string) {
    return token ? `Bearer ${token}` : null;
  }

      // 请求头处理
  client.addRequestInterceptor({
    fulfilled: async (config) => {
      const accessStore = useAccessStore();

      // 🔥 移除频繁的Token检查，由定时任务负责自动续期
      // 只设置请求头，不进行额外的Token验证
      config.headers.Authorization = formatToken(accessStore.accessToken);
      config.headers['Accept-Language'] = preferences.app.locale;
      return config;
    },
  });

  // 🔥 Token自动续期处理拦截器 - 移到最前面，确保优先处理
  client.addResponseInterceptor({
    fulfilled: (response) => {
      // 🔥 添加调试日志
      console.log('🔍 响应拦截器：准备处理Token续期...');

      // 🔥 自动处理响应头中的token续期信息
      if (response && response.headers) {
        console.log('🔍 响应拦截器：发现响应头，调用tokenManager处理...');
        tokenManager.handleTokenFromResponse(response.headers);
      } else {
        console.log('🔍 响应拦截器：没有响应头或响应对象');
      }
      return response;
    },
    rejected: async (error) => {
      // 🔥 如果是Token相关错误，立即处理以防止浏览器显示认证对话框
      if (error.response?.status === 401) {
        console.warn('请求返回401，Token已过期，立即触发重新认证');

        // 停止自动续期任务
        tokenManager.stopAutoRefreshTask();

        // 清除认证状态
        const accessStore = useAccessStore();
        accessStore.setAccessToken(null);
        accessStore.setRefreshToken(null);
        accessStore.setLoginExpired(false);
        accessStore.setIsAccessChecked(false);

        // 🔥 立即触发重新认证，防止浏览器显示认证对话框
        setTimeout(async () => {
          await doReAuthenticate();
        }, 0);

        // 修改错误信息，防止浏览器处理
        const customError = new Error('Token已过期，正在跳转到登录页');
        customError.name = 'TokenExpiredError';
        return Promise.reject(customError);
      }
      return Promise.reject(error);
    },
  });

  // response数据解构
  client.addResponseInterceptor<HttpResponse>({
    fulfilled: (response) => {
      const { data: responseData, status } = response;

      const { code, data, message: msg } = responseData;
      if (status >= 200 && status < 400 && code === 200) {
        return data;
      }
      
      // 改进错误信息处理，避免 undefined: undefined
      let errorMessage = '请求失败';
      if (msg && msg !== 'undefined') {
        errorMessage = msg;
        if (data && data !== 'undefined') {
          errorMessage += `: ${data}`;
        }
      } else if (data && data !== 'undefined') {
        errorMessage = `请求失败: ${data}`;
      } else {
        errorMessage = `请求失败 (状态码: ${status}, 错误码: ${code || '未知'})`;
      }
      
      throw new Error(errorMessage);
    },
  });

  // token过期的处理
  client.addResponseInterceptor(
    authenticateResponseInterceptor({
      client,
      doReAuthenticate,
      doRefreshToken,
      enableRefreshToken: true, // 这里设为true，具体的开关控制在doRefreshToken中处理
      formatToken,
    }),
  );

  // 通用的错误处理,如果没有进入上面的错误处理逻辑，就会进入这里
  client.addResponseInterceptor(
    errorMessageResponseInterceptor((msg: string) => {
      // 如果是验证错误 (code === 201)，直接使用后端返回的 message
      message.error(msg);
    }),
  );

  return client;
}

export const requestClient = createRequestClient(apiURL);

export const baseRequestClient = new RequestClient({ baseURL: apiURL });

// 创建专门用于认证API的客户端，不添加token检查拦截器
function createAuthRequestClient(baseURL: string) {
  const client = new RequestClient({
    baseURL,
  });

  // 只添加基本的响应数据解构
  client.addResponseInterceptor<HttpResponse>({
    fulfilled: (response) => {
      const { data: responseData, status } = response;

      const { code, data, message: msg } = responseData;
      if (status >= 200 && status < 400 && code === 200) {
        return data;
      }
      
      // 改进错误信息处理，避免 undefined: undefined
      let errorMessage = '请求失败';
      if (msg && msg !== 'undefined') {
        errorMessage = msg;
        if (data && data !== 'undefined') {
          errorMessage += `: ${data}`;
        }
      } else if (data && data !== 'undefined') {
        errorMessage = `请求失败: ${data}`;
      } else {
        errorMessage = `请求失败 (状态码: ${status}, 错误码: ${code || '未知'})`;
      }
      
      throw new Error(errorMessage);
    },
  });

  // 添加语言header
  client.addRequestInterceptor({
    fulfilled: async (config) => {
      config.headers['Accept-Language'] = preferences.app.locale;
      return config;
    },
  });

  return client;
}

export const authRequestClient = createAuthRequestClient(apiURL);
